<< CodingTheory`

H = {{1, 1, 1, 1}, {1, 1, 0, 1}, {1, 0, 1, 
          0}}

?AugmentedCode

AugmentedCode[H]

?BinaryGaloisField

g = 1 + x + x^3; 
    BinaryGaloisField[g, x, b, a]

?BinaryIrreduciblePolynomials

n = 5; BinaryIrreduciblePolynomials[n, x]

?BurstRectangularCodeVector

n = 3; m = 4; inf = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}; 
    BurstRectangularCodeVector[n, m, inf]

?CyclicCode

g = 1 + x + x^3; n = 7; CyclicCode[g, n, x]

?DecHammingCode

m = 3; w = {1, 1, 1, 1, 0, 1, 1}; DecHammingCode[m, w]

?DecRectangularCode

n = 2; m = 3; w = {0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1}; 
    DecRectangularCode[n, m, w]

?DimensionCode

H = {{1, 1, 1, 1}, {1, 1, 0, 1}};
DimensionCode[H]

?DistanceCode

DistanceCode[H]

?DualCode

DualCode[H]

?EquivalentCode

q = {1, 2, 4, 3}; EquivalentCode[H, q]

?ErrorTrappingDecodeBCHCode

w = {1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; 
    ErrorTrappingDecodeBCHCode[w]

?ErrorTrappingDecodeHammingCode

w = {1, 1, 1, 1, 0, 1, 0}; 
    ErrorTrappingDecodeHammingCode[w, x]

?ExpurgatingCode

H = {{1, 1, 1, 1}, {1, 1, 0, 1}, {1, 0, 1, 
          0}}
ExpurgatingCode[H]

?ExtendedCode

H
ExtendedCode[H]

?GeneratorMatrix

H
GeneratorMatrix[H]

?GeneratorPolynomials

n = 7; GeneratorPolynomials[n, x]

?GilbertVarshamovBound

n = 10; k = 2; d = 3; 
    GilbertVarshamovBound[n, k, d];
n = 10; k = 2; Clear[d]; 
    GilbertVarshamovBound[n, k, d]
n = 10; Clear[k]; d = 3; 
    GilbertVarshamovBound[n, k, d]
Clear[n]; k = 2; d = 3; 
    GilbertVarshamovBound[n, k, d]
Clear[n, k]; d = 3; 
    GilbertVarshamovBound[n, k, d]

?HammingBound

n = 10; k = 2; d = 3; 
    HammingBound[n, k, d]
n = 10; k = 2; Clear[d]; 
    HammingBound[n, k, d]
n = 10; Clear[k]; d = 3; 
    HammingBound[n, k, d]
Clear[n]; k = 2; d = 3; 
    HammingBound[n, k, d]
Clear[n, k]; d = 3; HammingBound[n, k, d]

?HammingCode

m = 
        3 ;inf = {1, 1, 1, 0} ;HammingCode[m, 
      inf]

?HammingMatrix

m = 3; HammingMatrix[m]

?McWilliamsIdentity

f = 1 + x^7; n = 7; 
    McWilliamsIdentity[f, n, x]

?MeggittDecode

g = 1 + x + x^3; n = 7; w = {1, 1, 0, 1, 0, 1, 0}; 
    MeggittDecode[g, w, n, x]

?NonsystematicEncodeCyclicCode

g = 1 + x + x^3; n = 7; inf = {1, 1, 0, 1}; 
    NonsystematicEncodeCyclicCode[g, inf, n, x]

?ParityCheckMatrix

G = {{1, 1, 1}, {1, 0, 1}}
ParityCheckMatrix[G]

?PuncturedCode

n = 2; H
PuncturedCode[H, n]

?RectangularCode

inf = {1, 1, 1, 1, 0, 1}; n = 3; m = 2; 
    RectangularCode[n, m, inf]

?ShowBinaryGaloisField

g = 1 + x + x^4; 
    ShowBinaryGaloisField[g, x, b, a]

?ShowBurstRectangularCodeVector

n = 5; m = 2; 
    inf = {1, 1, 0, 0, 1, 1, 0, 0, 1, 1};
ShowBurstRectangularCodeVector[n, m, inf, 
      X]

?ShowCorrectBurstRectangularCode

n = 5; m = 2; 
    w = {1, 1, 1, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 1, 
        1};
ShowCorrectBurstRectangularCode[n, m, w, 
      X]

?ShowCyclicCode

g = 1 + x + x^3; n = 7; ShowCyclicCode[g, n, x]

?ShowDecHammingCode

m = 3; w = {1, 1, 1, 1, 0, 1, 1}; ShowDecHammingCode[m, w]

?ShowDecRectangularCode

n = 2; m = 3; w = {0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1}; 
    ShowDecRectangularCode[n, m, w]

?ShowErrorTrappingDecoderBCHCode

ShowErrorTrappingDecoderBCHCode

?ShowHammingCode

m = 
        3 ;inf = {1, 1, 1, 0} ;ShowHammingCode[m, 
      inf]

?ShowMeggittDecoder

g = 1 + x + x^3; n = 7; 
    ShowMeggittDecoder[g, n, x]

?ShowNonsystematicEncoderCyclicCode

g = 1 + x + x^3; n = 7; 
    ShowNonsystematicEncoderCyclicCode[g, n, x]

?ShowReconstructInformRectangularCode

n = 2; m = 3; 
    w = {0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1};
ShowReconstructInformRectangularCode[n, m, w, X]

?ShowRectangularCode

n = 2; m = 3; inf = {1, 1, 0, 1, 1, 1};
ShowRectangularCode[n, m, inf, X]

?ShowStandardArrays

H=(({{1, 1, 1, 1}, {1, 1, 0, 1}, {1, 0, 1, 0}}));w = {1, 1, 0, 1};ShowStandardArrays[H, w]

?ShowSystematicEncode

H = {{0, 1, 1, 1, 0, 0, 1}, {1, 1, 0, 1, 1, 0, 
            1}};
inf = {1, 0, 0, 1, 1}; ShowSystematicEncode[H, inf, x]

M=(({{0, 1, 1, 0, 1, 1, 0}, {1, 1, 1, 0, 1, 0, 1}}));ShowSystematicEncode[M, inf, x]

?ShowSystematicEncoderCyclicCode

g = 1 + x + x^3; n = 7; 
    ShowSystematicEncoderCyclicCode[g, n, x]

?ShowTableMult

n = 8; ShowTableMult[n]

?ShowTablePlus

ShowTablePlus[n]

?SingletonBound

n = 10; k = 2; d = 3; 
    SingletonBound[n, k, d]
n = 10; k = 2; Clear[d]; 
    SingletonBound[n, k, d]
n = 10; Clear[k]; d = 3; 
    SingletonBound[n, k, d]
Clear[n]; k = 2; d = 3; 
    SingletonBound[n, k, d]
Clear[n, k]; d = 3; 
    SingletonBound[n, k, d]

H=(({{0, 1, 1, 0, 1, 1, 0}, {1, 1, 1, 0, 1, 0, 1}}));v = {1, 1, 1, 1, 1, 1, 1};Syndrome[H, v]

?SystematicEncode

H = {{0, 1, 1, 1, 0, 0, 1}, {1, 1, 0, 1, 1, 0, 
            1}};
inf = {1, 0, 0, 1, 1}; SystematicEncode[H, inf, x]

?SystematicEncodeCyclicCode

g = 1 + x + x^3; inf = {1, 1, 0, 1}; n = 7; 
    SystematicEncodeCyclicCode[g, inf, n, x]

?VEC

VEC[1000, 10]

?WeightPolynomial

H = HammingMatrix[3] ;WeightPolynomial[
      H, x]